package com.zkjd.lingdong.service.executor

import android.content.Context
import com.adayo.service.utils.DriveModelManager
import com.mega.nexus.os.MegaSystemProperties
import com.zkjd.lingdong.data.FunctionsConfig
import com.zkjd.lingdong.model.ButtonFunction
import com.zkjd.lingdong.model.ButtonType
import com.zkjd.lingdong.repository.DeviceEvent
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.SharedFlow
import mega.car.MegaCarProperty
import mega.car.Signal.CDC_2D2_CDCLERECHILDLOCKREQ
import mega.car.Signal.CDC_2D2_CDCRIRECHILDLOCKREQ
import mega.car.Signal.GW_288_BDCLERECHILDLOCKSTS
import mega.car.Signal.GW_288_BDCRIRECHILDLOCKSTS
import mega.car.hardware.CarPropertyValue
import timber.log.Timber
import javax.inject.Inject
import javax.inject.Singleton

private const val TAG = "MeiJiaCarFunctionExecutor"

/**
 * 美佳车型功能执行器
 * 负责处理车辆控制相关功能，如空调、座椅、车门等控制
 */
@Singleton
class MeiJiaCarFunctionExecutor @Inject constructor(
    private val context: Context
) {

    /** 设备事件流 */
    private val deviceEventsFlow = MutableSharedFlow<DeviceEvent>(replay = 0)

    /**
     * 获取设备事件流
     * @return 设备事件共享流
     */
    fun getDeviceEvents(): SharedFlow<DeviceEvent> = deviceEventsFlow
    // Car属性工具类
    private val mCarProperty: MegaCarProperty by lazy {
        MegaCarProperty.getInstance()
    }
    
    // 车辆功能相关CAN信号ID常量
    companion object {
        // 后备箱控制
        private const val ID_DOOR_BACK = 0x6000031
        // 儿童锁控制
        private const val ID_CHILD_LOCK_LEFT = 0x64000164
        private const val ID_CHILD_LOCK_RIGHT = 0x64000165
        // 方向盘加热
        private const val ID_STEERING_WHEEL_HEATING = 0x3000001
        // 座椅加热（主驾、副驾）
        private const val ID_SEAT_HEAT_FRONTLEFT = 0x2000088
        private const val ID_SEAT_HEAT_FRONTRIGHT = 0x2000089
        // 空调温度调节
        private const val ID_TEMPERATURE_FRONTLEFT = 0x2000077
        private const val ID_TEMPERATURE_FRONTRIGHT = 0x2000078
        // 空调风量调节
        private const val ID_BLW_LEVEL_FRONT = 0x200007e
        // 空调吹风方向
        private const val ID_BLW_DIRECT_FRONT = 0x2000084
        // 驾驶模式
        private const val ID_DRV_MODE = 0x4000006
        // 能量管理模式
        private const val ID_ENERGY_MANAGEMENT_MODE = 0x4000031
        private const val ID_DRV_ENERGY_MODE = 0x4000015
        // 前后除霜除雾
        private const val ID_REQ_FRONT_DEFROST = 0x2000036
        private const val ID_REAR_DEFROST = 0x200001b
        // 按摩控制
        private const val ID_DSM_PARK_MASSAGE_STR = 0x64000180
        private const val ID_PSM_PARK_MASSAGE_STR = 0x64000184
        private const val ID_DSM_PARK_MASSAGE_MOD = 0x6400017f
        private const val ID_PSM_PARK_MASSAGE_MOD = 0x64000183
        // 尾翼档位
        private const val ID_PTS_ELE_TAIL_FUN_SET = 0x64000221
        // 副驾屏展开度数
        private const val ID_CDC_TURN_VOICE_CTRL = 0x6400011e
        //前排空调开关 关闭
        private const val ID_WHOLE_CABIN_AIR_CD_FRONT=0x200006a
        //前排空调开关 运行
        private const val ID_AC_RUN_REQ=0x2000042

        //小憩模式 运行
        private const val ID_DC_3BD_CDCRESPITESETSTS=0x6400016a
        //小憩模式 运行
        private const val ID_RESPITE_MODE=0x7000024
        //后视镜开关
        private const val ID_REAR_VIEW_MIRROR_FOLD_CONTROL=0x1000007
        //二排安全带未系报警提示音
        private const val ID_SEAT_BELT_CHECK_REAR=0x3000078
        //雨刮模式
        private const val ID_WIPER_FRONT=0x9000081
        //低速行人报警音
        private const val ID_ACOUSTIC_VEH_ALERT=0xa000007

        private const val ID_CHIME_AVAS_PREVIEW=0x7000032
        //主驾座椅通风
        private const val ID_SEAT_VENT_FRONTLEFT=0x200008d
        //副驾座椅通风
        private const val ID_SEAT_VENT_FRONTRIGHT=0x200008e
        //老板键 副驾座椅移动控制
        private const val ID_SEAT_POSITION_FRONTRIGHT=0x300005d

    }

    /**
     * 执行车辆相关功能
     * @param function 要执行的功能
     * @param buttonType 触发的按键类型，用于处理旋转功能
     */
    suspend fun executeCarFunction(
        function: ButtonFunction,
        buttonType: ButtonType = ButtonType.SHORT_PRESS,
        macAddress: String
    ) {
        Timber.tag(TAG)
            .d("执行车辆功能: ${function.name}, 代码: ${function.actionCode}, 按键类型: $buttonType")

        val array=function.useType.toString().split("")
        // 处理旋转类功能
        if (array[1].toInt()==2 &&
           (buttonType == ButtonType.LEFT_ROTATE || buttonType == ButtonType.RIGHT_ROTATE)) {
            when (function.actionCode) {
                "CAR_AC_TEMPERATURE1" -> {
                    // 空调温度调节
                    if (buttonType == ButtonType.RIGHT_ROTATE) {
                        // 顺时针旋转，增加温度
                        increaseACTemperature()
                    } else {
                        // 逆时针旋转，降低温度
                        decreaseACTemperature()
                    }
                    return
                }
                "CAR_AC_TEMPERATURE2" -> {
                    // 空调温度调节
                    if (buttonType == ButtonType.RIGHT_ROTATE) {
                        // 顺时针旋转，增加温度
                        increaseACTemperature2()
                    } else {
                        // 逆时针旋转，降低温度
                        decreaseACTemperature2()
                    }
                    return
                }
                "CAR_AC_FAN_SPEED" -> {
                    // 空调风量调节
                    if (buttonType == ButtonType.RIGHT_ROTATE) {
                        // 顺时针旋转，增加风量
                        increaseFanSpeed()
                    } else {
                        // 逆时针旋转，降低风量
                        decreaseFanSpeed()
                    }
                    return
                }

                //老板键
                "CAR_BOSS_KEY" -> {
                    if (buttonType == ButtonType.RIGHT_ROTATE) {
                        // 顺时针旋转，增加风量
                        toFrontRight()
                    } else {
                        // 逆时针旋转，降低风量
                        toFrontLeft()
                    }
                    return

                }
            }
        }
        
        // 处理普通功能
        when (function.actionCode) {
            // 后备箱相关功能
            "CAR_TRUNK_TOGGLE" -> toggleTrunk()
            
            // 车门相关功能
            "CAR_CHILD_LOCK_TOGGLE1" -> toggleChildLock1()
            "CAR_CHILD_LOCK_TOGGLE2" -> toggleChildLock2()
            
            // 座椅相关功能
            "CAR_STEERING_WHEEL_HEAT_TOGGLE" -> toggleSteeringWheelHeat()
            "CAR_MAIN_SEAT_HEAT_TOGGLE" -> toggleMainSeatHeat()
            "CAR_COPILOT_SEAT_HEAT_TOGGLE" -> toggleCopilotSeatHeat()
            
            // 按摩相关功能
            "CAR_MASSAGE_INTENSITY" -> adjustMassageIntensity()
            "CAR_MASSAGE_MODE" -> adjustMassageMode()
            
            // 空调相关功能
            "CAR_AC_TEMPERATURE_UP" -> increaseACTemperature()
            "CAR_AC_TEMPERATURE_DOWN" -> decreaseACTemperature()
            "CAR_FAN_SPEED_UP" -> increaseFanSpeed()
            "CAR_FAN_SPEED_DOWN" -> decreaseFanSpeed()
            "CAR_AC_WIND_DIRECTION" -> adjustAcWindDirection()
            "CAR_DEFROST_TOGGLE" -> toggleDefrost()
            
            // 驾驶相关功能
            "CAR_DRIVING_MODE" -> {
                if (!FunctionsConfig.getInstance(context).getIs8295()) {
                    adjustDrivingMode()
                }else {
                    adjustDrivingMode2895()
                }
            }
            "CAR_ENERGY_MANAGEMENT" -> adjustEnergyManagement()
            
            // 尾翼控制
            "CAR_TRUNK_POSITION" -> adjustTailWingPosition()
            
            // 屏幕相关功能
            "CAR_COPILOT_SCREEN_TOGGLE" -> adjustCopilotScreen()
            //除雾除霜
            "CAR_DEFROST1" -> toggleDefrost1()
            "CAR_DEFROST2" -> toggleDefrost2()
            //空调开关
            "CAR_AIR_CONDITIONING" -> setAirCdFront()
            //主驾小憩模式
            "CAR_RESTING_MODE_LEFT" -> setCdcRespiteSetSts()
            //副驾小憩模式
            "CAR_RESTING_MODE_RIGHT" -> setCdcRespiteSetSts()
            //后视镜折叠
            "CAR_FOLDING_REARVIEW_MIRROR" -> toRearViewMirrorFold()
            //低速行人报警音
            "CAR_LOW_SPEED_PEDESTRIAN" -> toLowSpeedPedestrianAlarm()
            //二排安全带未系报警提示音
            "CAR_SEAT_BELT_NOTFASTENED" -> toSeatBeltCheck()
            //雨刮模式
            "CAR_WIPER_MODE" -> toWiper()

            //老板键
            "CAR_BOSS_KEY" -> toFrontRight()

            //主驾座椅通风开/关
            "CAR_LEFT_REAR_VENT_TOGGLE" -> toSeatVentilationLeft()

            //副驾座椅通风开/关
            "CAR_RIGHT_REAR_VENT_TOGGLE" -> toSeatVentilationRight()
            else -> {
                Timber.tag(TAG).w("未知车辆功能代码: ${function.actionCode}")
            }
        }
    }


    /**
     * 空调开关
     * 前排空调开关
     *
     * ID: 0x200006a (ID_WHOLE_CABIN_AIR_CD_FRONT)
     * ID: 0x2000042 (ID_AC_RUN_REQ)
     * 值类型: int
     */
    suspend fun setAirCdFront(){
        Timber.tag(TAG).w("前排空调开关")
        try {

            val currentSpeed = mCarProperty.getIntProp(ID_BLW_LEVEL_FRONT)

            Timber.tag(TAG).w("空调风扇速度: $currentSpeed")

            if(currentSpeed==0) {
                mCarProperty.setIntProp(ID_AC_RUN_REQ, 1)
                //deviceEventsFlow.emit(DeviceEvent.SetFunction("", "前排空调 开启"))
                Timber.tag(TAG).w("空调开关已设置为: 1")
            }else {
                mCarProperty.setIntProp(ID_WHOLE_CABIN_AIR_CD_FRONT, 0)

                //deviceEventsFlow.emit(DeviceEvent.SetFunction("", "前排空调 关闭"))
                Timber.tag(TAG).w("空调开关已设置为: 0")
            }

        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "空调开关设置失败")
        }
    }

    /**
     * 小憩模式
     * 情景模式
     *
     * ID: 0x6400016a (ID_DC_3BD_CDCRESPITESETSTS) 小憩模式座椅信号
     * ID: 0x7000024 (ID_RESPITE_MODE) 小憩模式开关信号
     * 值类型: int
     * 值说明:
     *   0关1开。
     * 小憩模式座椅信号发送同时
     * 需要发小憩模式开关信号
     * 座椅1\2\3发 1
     * 座椅0发 0
     *小憩模式座椅信号
     * 0x0:关闭
     * 0x1:主驾
     * 0x2:副驾
     * 0x3:前排
     */
    suspend fun setCdcRespiteSetSts(){
        Timber.tag(TAG).w("小憩模式")
        try {
            val currentState = mCarProperty.getIntProp(ID_DC_3BD_CDCRESPITESETSTS)
            Timber.tag(TAG).w("当前小憩模式座椅信号: $currentState")

            // 切换状态 (1→0, 0→1)
            val newState = when (currentState) {
                0 -> 1 // 如果当前关闭，则开启
                1 -> 2 // 如果当前非关闭状态，则关闭
                2 -> 3
                3 -> 0
                else -> 1
            }

            when(newState)
            {
                1-> mCarProperty.setIntProp(ID_RESPITE_MODE, 1)
                2-> mCarProperty.setIntProp(ID_RESPITE_MODE, 1)
                3-> mCarProperty.setIntProp(ID_RESPITE_MODE, 1)
                0-> mCarProperty.setIntProp(ID_RESPITE_MODE, 0)
            }
            mCarProperty.setIntProp(ID_DC_3BD_CDCRESPITESETSTS, newState)



            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "小憩模式${if (newState == 0) "关闭" else "开启"}"))
            Timber.tag(TAG).w("小憩模式开关已设置为: $newState")

        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "小憩模式开关设置失败")
        }
    }

    /**
     * 后视镜折叠
     * ID: 0x1000007 (ID_REAR_VIEW_MIRROR_FOLD_CONTROL)
     * 值类型: int
     */
    suspend fun toRearViewMirrorFold(){
        Timber.tag(TAG).w("后视镜折叠开关")
        try {

            val currentState = mCarProperty.getIntProp(ID_REAR_VIEW_MIRROR_FOLD_CONTROL)
            Timber.tag(TAG).w("当前后视镜折叠状态: $currentState")

            // 切换状态 (1→0, 0→1)
            val newState = when (currentState) {
                0 -> 1 // 如果当前关闭，则开启
                1 -> 0 // 如果当前非关闭状态，则关闭
                else -> 1
            }

            mCarProperty.setIntProp(ID_REAR_VIEW_MIRROR_FOLD_CONTROL, newState)


            //deviceEventsFlow.emit(DeviceEvent.SetFunction("", "后视镜折叠${if (newState == 0) "关闭" else "开启"}"))
            Timber.tag(TAG).w("后视镜折叠开关已设置为: $newState")

        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "后视镜折叠开关设置失败")
        }
    }

    /**
     * 二排安全带未系报警提示音
     * ID: 0x3000078 (ID_SEAT_BELT_CHECK_REAR)
     * 值类型: int
     */
    suspend fun toSeatBeltCheck(){
        Timber.tag(TAG).w("二排安全带未系报警提示音开关")
        try {

            val currentState = mCarProperty.getIntProp(ID_SEAT_BELT_CHECK_REAR)
            Timber.tag(TAG).w("当前二排安全带未系报警提示音开关状态: $currentState")

            // 切换状态 (1→0, 0→1)
            val newState = when (currentState) {
                0 -> 1 // 如果当前关闭，则开启
                1 -> 0 // 如果当前非关闭状态，则关闭
                else -> 1
            }

            mCarProperty.setIntProp(ID_SEAT_BELT_CHECK_REAR, newState)


            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "二排安全带未系报警提示音${if (newState == 0) "关闭" else "开启"}"))
            Timber.tag(TAG).w("二排安全带未系报警提示音开关已设置为: $newState")

        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "二排安全带未系报警提示音开关设置失败")
        }
    }

    /**
     * 雨刮模式
     * ID: 0x9000081 (ID_WIPER_FRONT)
     * 值类型: int
     */
    suspend fun toWiper(){
        Timber.tag(TAG).w("雨刮模式开关")
        try {

            val currentState = mCarProperty.getIntProp(ID_WIPER_FRONT)
            Timber.tag(TAG).w("雨刮模式开关状态: $currentState")

            // 切换状态 (1→0, 0→1)
            val newState = when (currentState) {
                0 -> 1 // 如果当前关闭，则开启
                1 -> 2 // 如果当前非关闭状态，则关闭
                2 -> 3
                3 -> 0
                else -> 1
            }

            mCarProperty.setIntProp(ID_WIPER_FRONT, newState)


            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "雨刮模式${if (newState == 0) "关闭" else "开启"}"))
            Timber.tag(TAG).w("雨刮模式开关已设置为: $newState")

        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "雨刮模式开关设置失败")
        }
    }


    /**
     * 低速行人报警音
     * ID: 0xa000007 (ID_ACOUSTIC_VEH_ALERT)
     * 值类型: int
     */
    suspend fun toLowSpeedPedestrianAlarm(){
        Timber.tag(TAG).w("低速行人报警音开关")
        try {

            val currentState = mCarProperty.getIntProp(ID_ACOUSTIC_VEH_ALERT)
            Timber.tag(TAG).w("低速行人报警音开关状态: $currentState")

            // 切换状态 (1→0, 0→1)
            val newState = when (currentState) {
                0 -> 1 // 如果当前关闭，则开启
                1 -> 0 // 如果当前非关闭状态，则关闭
                else -> 1
            }

            mCarProperty.setIntProp(ID_ACOUSTIC_VEH_ALERT, newState)
            mCarProperty.setIntProp(ID_CHIME_AVAS_PREVIEW, newState)


            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "低速行人报警音${if (newState == 0) "关闭" else "开启"}"))
            Timber.tag(TAG).w("低速行人报警音开关已设置为: $newState")

        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "低速行人报警音开关设置失败")
        }
    }

    /**
     * 主驾通风
     * ID: 0x200008d (ID_SEAT_VENT_FRONTLEFT)
     * 值类型: int
     */
    suspend fun toSeatVentilationLeft(){
        Timber.tag(TAG).w("主驾通风开关")
        try {

            val currentState = mCarProperty.getIntProp(ID_SEAT_VENT_FRONTLEFT)
            Timber.tag(TAG).w("主驾通风开关状态: $currentState")

            // 循环切换档位 (0→1→2→3→0)
            val newLevel = (currentState + 1) % 4

            val nameStirng = when (newLevel) {
                0 -> "关闭"  // 舒适→运动
                1 -> "低"  // 运动→经济
                2 -> "中"  // 经济→专属
                3 -> "高"  // 专属→自定义
                else -> "关闭" // 其他→舒适
            }

            mCarProperty.setIntProp(ID_SEAT_VENT_FRONTLEFT, newLevel)


            //deviceEventsFlow.emit(DeviceEvent.SetFunction("", "主驾座椅通风 $nameStirng"))
            Timber.tag(TAG).w("主驾通风开关已设置为: $newLevel")

        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "主驾通风开关设置失败")
        }
    }

    /**
     * 副驾通风
     * ID: 0x200008e (ID_SEAT_VENT_FRONTRIGHT)
     * 值类型: int
     */
    suspend fun toSeatVentilationRight(){
        Timber.tag(TAG).w("副驾通风开关")
        try {

            val currentState = mCarProperty.getIntProp(ID_SEAT_VENT_FRONTRIGHT)
            Timber.tag(TAG).w("副驾通风开关状态: $currentState")

            // 循环切换档位 (0→1→2→3→0)
            val newLevel = (currentState + 1) % 4

            val nameStirng = when (newLevel) {
                0 -> "关闭"  // 舒适→运动
                1 -> "低"  // 运动→经济
                2 -> "中"  // 经济→专属
                3 -> "高"  // 专属→自定义
                else -> "关闭" // 其他→舒适
            }

            mCarProperty.setIntProp(ID_SEAT_VENT_FRONTRIGHT, newLevel)


            //deviceEventsFlow.emit(DeviceEvent.SetFunction("", "副驾座椅通风 $nameStirng"))
            Timber.tag(TAG).w("副驾通风开关已设置为: $newLevel")

        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "副驾通风开关设置失败")
        }
    }

    /**
     * 老板键
     * ID: 0x300005d (ID_SEAT_POSITION_FRONTRIGHT)
     * 值类型: int
     */
    suspend fun toFrontRight(){
        Timber.tag(TAG).w("老板键增加状态")
        try {

            val currentState = mCarProperty.getIntProp(ID_SEAT_POSITION_FRONTRIGHT)
            Timber.tag(TAG).w("老板键增加状态: $currentState")

            val carPropertyValue = CarPropertyValue(ID_SEAT_POSITION_FRONTRIGHT,1)
            carPropertyValue.setExtension(3)
            mCarProperty.setRawProp(carPropertyValue)

            Thread.sleep(500)

            val carPropertyValue2 = CarPropertyValue(ID_SEAT_POSITION_FRONTRIGHT,0)
            carPropertyValue2.setExtension(3)
            mCarProperty.setRawProp(carPropertyValue2)


            //deviceEventsFlow.emit(DeviceEvent.SetFunction("", "副座后移"))
            Timber.tag(TAG).w("老板键增加状态: $currentState")

        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "老板键增加状态")
        }
    }

    /**
     * 老板键
     * ID: 0x300005d (ID_SEAT_POSITION_FRONTRIGHT)
     * 值类型: int
     */
    suspend fun toFrontLeft(){
        Timber.tag(TAG).w("老板键减少状态")
        try {

            val currentState = mCarProperty.getIntProp(ID_SEAT_POSITION_FRONTRIGHT)
            Timber.tag(TAG).w("老板键减少状态: $currentState")

            val carPropertyValue = CarPropertyValue(ID_SEAT_POSITION_FRONTRIGHT,1)
            carPropertyValue.setExtension(2)
            mCarProperty.setRawProp(carPropertyValue)

            Thread.sleep(500)

            val carPropertyValue2 = CarPropertyValue(ID_SEAT_POSITION_FRONTRIGHT,0)
            carPropertyValue2.setExtension(2)
            mCarProperty.setRawProp(carPropertyValue2)

            //deviceEventsFlow.emit(DeviceEvent.SetFunction("", "副座前移"))
            Timber.tag(TAG).w("老板键减少状态: $currentState+10")

        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "老板键减少状态失败")
        }
    }

    /**
     * 切换后备箱开关状态
     * 
     * ID: 0x6000031 (ID_DOOR_BACK)
     * 值类型: int
     * 值说明: 
     *   0=关闭
     *   1=开启
     *   2=打开中
     *   3=关闭中
     *   4=停止
     */
    private suspend fun toggleTrunk() {
        Timber.tag(TAG).w("切换后备箱开关状态")
        try {
            // 获取当前后备箱状态
            val currentState = mCarProperty.getIntProp(ID_DOOR_BACK)
            Timber.tag(TAG).w("当前后备箱状态: $currentState")
            
            // 切换状态 (0→1, 其他→0)
            val newState = when (currentState) {
                0 -> 1 // 如果当前关闭，则开启
                else -> 0 // 如果当前非关闭状态，则关闭
            }
            
            // 设置新状态
            mCarProperty.setIntProp(ID_DOOR_BACK, newState)
            //deviceEventsFlow.emit(DeviceEvent.SetFunction("", "后备箱${if (newState == 1) "开启" else "关闭"}"))

            Timber.tag(TAG).w("设置后备箱状态为: ${if (newState == 1) "开启" else "关闭"}")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "切换后备箱状态失败")
        }
    }
    
    /**
     * 切换儿童锁开关状态
     * 同时控制左右后儿童锁
     * 
     * ID: 0x64000164 (ID_CHILD_LOCK_LEFT)
     * ID: 0x64000165 (ID_CHILD_LOCK_RIGHT)
     * 值类型: int
     * 值说明:
     *   0x0=关闭
     *   0x1=开启
     */
    private suspend fun toggleChildLock1() {
        Timber.tag(TAG).w("切换左儿童锁开关状态")
        try {
            // 获取当前左侧儿童锁状态
            val currentStateLeft = mCarProperty.getIntProp(GW_288_BDCLERECHILDLOCKSTS)
            Timber.tag(TAG).w("当前儿童锁状态: 左=$currentStateLeft")
            
            // 切换状态 (0→1, 1→0)
            val newState = if (currentStateLeft == 0 ) 2 else 1
            
            // 设置新状态
            mCarProperty.setIntProp(CDC_2D2_CDCLERECHILDLOCKREQ, newState)

            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "左儿童锁${if (newState == 2) "开启" else "关闭"}"))
            Timber.tag(TAG).w("设置左儿童锁状态为: ${if (newState == 2) "开启" else "关闭"}")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "切换左儿童锁状态失败")
        }
    }

    /**
     * 切换儿童锁开关状态
     * 同时控制左右后儿童锁
     *
     * ID: 0x64000164 (ID_CHILD_LOCK_LEFT)
     * ID: 0x64000165 (ID_CHILD_LOCK_RIGHT)
     * 值类型: int
     * 值说明:
     *   0x0=关闭
     *   0x1=开启
     */
    private suspend fun toggleChildLock2() {
        Timber.tag(TAG).w("切换右儿童锁开关状态")
        try {
            // 获取当前左侧儿童锁状态
            val currentStateRight = mCarProperty.getIntProp(GW_288_BDCRIRECHILDLOCKSTS)
            Timber.tag(TAG).w("当前儿童锁状态:右=$currentStateRight")

            // 切换状态 (0→1, 1→0)
            val newState = if ( currentStateRight == 0) 2 else 1

            // 设置新状态
            mCarProperty.setIntProp(CDC_2D2_CDCRIRECHILDLOCKREQ, newState)

            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "右儿童锁${if (newState == 2) "开启" else "关闭"}"))
            Timber.tag(TAG).w("设置右儿童锁状态为: ${if (newState == 2) "开启" else "关闭"}")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "切换右儿童锁状态失败")
        }
    }

    /**
     * 切换方向盘加热开关状态
     * 
     * ID: 0x3000001 (ID_STEERING_WHEEL_HEATING)
     * 值类型: int
     * 值说明:
     *   0x0=关闭
     *   0x1=开启
     */
    private suspend fun toggleSteeringWheelHeat() {
        Timber.tag(TAG).w("切换方向盘加热开关状态")
        try {
            // 获取当前方向盘加热状态
            val currentState = mCarProperty.getIntProp(ID_STEERING_WHEEL_HEATING)
            Timber.tag(TAG).w("当前方向盘加热状态: $currentState")
            
            // 切换状态 (0→1, 1→0)
            val newState = if (currentState == 0) 1 else 0
            
            // 设置新状态
            mCarProperty.setIntProp(ID_STEERING_WHEEL_HEATING, newState)

            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "方向盘加热 ${if (newState == 1) "开启" else "关闭"}"))
            Timber.tag(TAG).w("设置方向盘加热状态为: ${if (newState == 1) "开启" else "关闭"}")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "切换方向盘加热状态失败")
        }
    }
    
    /**
     * 切换主驾座椅加热档位
     * 
     * ID: 0x2000088 (ID_SEAT_HEAT_FRONTLEFT)
     * 值类型: int
     * 值说明:
     *   0=关闭
     *   1=低档
     *   2=中档
     *   3=高档
     */
    private suspend fun toggleMainSeatHeat() {
        Timber.tag(TAG).w("切换主驾座椅加热档位")
        try {
            // 获取当前主驾座椅加热状态
            val currentLevel = mCarProperty.getIntProp(ID_SEAT_HEAT_FRONTLEFT)
            Timber.tag(TAG).w("当前主驾座椅加热等级: $currentLevel")
            
            // 循环切换档位 (0→1→2→3→0)
            val newLevel = (currentLevel + 1) % 4

            val nameStirng = when (newLevel) {
                0 -> "关闭"  // 舒适→运动
                1 -> "低"  // 运动→经济
                2 -> "中"  // 经济→专属
                3 -> "高"  // 专属→自定义
                else -> "关闭" // 其他→舒适
            }
            
            // 设置新状态
            mCarProperty.setIntProp(ID_SEAT_HEAT_FRONTLEFT, newLevel)

            //deviceEventsFlow.emit(DeviceEvent.SetFunction("", "主驾座椅加热 $nameStirng "))
            Timber.tag(TAG).w("设置主驾座椅加热为: $newLevel")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "设置主驾座椅加热失败")
        }
    }
    
    /**
     * 切换副驾座椅加热档位
     * 
     * ID: 0x2000089 (ID_SEAT_HEAT_FRONTRIGHT)
     * 值类型: int
     * 值说明:
     *   0=关闭
     *   1=低档
     *   2=中档
     *   3=高档
     */
    private suspend fun toggleCopilotSeatHeat() {
        Timber.tag(TAG).w("切换副驾座椅加热档位")
        try {
            // 获取当前副驾座椅加热状态
            val currentLevel = mCarProperty.getIntProp(ID_SEAT_HEAT_FRONTRIGHT)
            Timber.tag(TAG).w("当前副驾座椅加热等级: $currentLevel")
            
            // 循环切换档位 (0→1→2→3→0)
            val newLevel = (currentLevel + 1) % 4

            val nameStirng = when (newLevel) {
                0 -> "关闭"  // 舒适→运动
                1 -> "低"  // 运动→经济
                2 -> "中"  // 经济→专属
                3 -> "高"  // 专属→自定义
                else -> "关闭" // 其他→舒适
            }
            
            // 设置新状态
            mCarProperty.setIntProp(ID_SEAT_HEAT_FRONTRIGHT, newLevel)

            //deviceEventsFlow.emit(DeviceEvent.SetFunction("", "副驾座椅加热 $nameStirng "))
            Timber.tag(TAG).w("设置副驾座椅加热为: $newLevel")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "设置副驾座椅加热失败")
        }
    }

    /**
     * 切换驾驶模式
     * 
     * ID: 0x4000006 (ID_DRV_MODE)
     * 值类型: int
     * 值说明:
     *   1=舒适模式
     *   2=运动模式
     *   3=经济模式
     *   4=专属模式
     *   5=自定义模式
     * 
     * @return 当前模式描述
     */
    suspend fun adjustDrivingMode(): String {
        Timber.tag(TAG).w("切换驾驶模式")
        try {
            // 获取当前驾驶模式
            val currentMode = mCarProperty.getIntProp(ID_DRV_MODE)
            Timber.tag(TAG).w("当前驾驶模式: $currentMode")
            
            // 需要的extension参数(385车型)
            val extensionParams: IntArray
            
            // 循环切换驾驶模式: 1舒适→2运动→4专属→0自定义→3经济→1舒适
            val newMode = when (currentMode) {
                1 -> 2  // 舒适→运动
                2 -> 4  // 运动→专属
                3 -> 1  // 经济→舒适
                4 -> 0  // 专属→自定义
                0 -> 3
                else -> 1 // 其他→舒适
            }

            Timber.tag(TAG).w("走到这")
            // 设置新的驾驶模式
//            val carPropertyValue = CarPropertyValue(ID_DRV_MODE,newMode)
//            carPropertyValue.setExtension(extensionParams)
//            mCarProperty.setRawProp(carPropertyValue)

            DriveModelManager.setDriveMode(newMode,context)

            // 获取模式描述
            val modeDesc = when (newMode) {
                1 -> "舒适模式"
                2 -> "运动模式"
                3 -> "经济模式"
                4 -> "专属模式"
                0 -> "自定义模式"
                else -> "未知模式"
            }

            val deeee = when (newMode) {
                1 -> "{1, 1, 1, 1}" // 舒适
                2 -> "{1, 2, 2, 2}" // 运动
                3 -> "{1, 2, 2, 2}" // 经济
                4 -> "{1, 1, 1, 1}"// 专属(与舒适相同，实际应弹窗选择)
//                5 -> intArrayOf(1, 1, 1, 1) // 自定义(实际应使用保存的自定义值)
                else -> "默认{1, 1, 1, 1}"
            }

            deviceEventsFlow.emit(DeviceEvent.SetFunction("", modeDesc))
            Timber.tag(TAG).w("设置驾驶模式为: $modeDesc ($deeee)")
            return ""
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "切换驾驶模式失败")
            return "操作失败"
        }
    }


    /**
     * 切换驾驶模式
     *
     * ID: 0x4000006 (ID_DRV_MODE)
     * 值类型: int
     * 值说明:
     *   1=舒适模式
     *   2=运动模式
     *   3=经济模式
     *   4=专属模式
     *   5=自定义模式
     *
     * @return 当前模式描述
     */
    suspend fun adjustDrivingMode2895(): String {
        Timber.tag(TAG).w("切换驾驶模式")
        try {
            // 获取当前驾驶模式
            val currentMode = mCarProperty.getIntProp(ID_DRV_MODE)
            Timber.tag(TAG).w("当前驾驶模式: $currentMode")

            // 需要的extension参数(385车型)
            val extensionParams: IntArray

            // 循环切换驾驶模式: 1舒适→2运动→3经济→4专属→0自定义→1舒适
            val newMode = when (currentMode) {
                1 -> 2  // 舒适→运动
                2 -> 3  // 运动→经济
                3 -> 4  // 经济→专属
                4 -> 0  // 专属→自定义
                0 -> 1
                else -> 1 // 其他→舒适
            }

//            Timber.tag(TAG).w("走到这")
            // 设置新的驾驶模式
//            val carPropertyValue = CarPropertyValue(ID_DRV_MODE,newMode)
//            carPropertyValue.setExtension(extensionParams)
//            mCarProperty.setRawProp(carPropertyValue)

            DriveModelManager.setDriveMode(newMode,context)

            // 获取模式描述
            val modeDesc = when (newMode) {
                1 -> "舒适模式"
                2 -> "运动模式"
                3 -> "经济模式"
                4 -> "专属模式"
                0 -> "自定义模式"
                else -> "未知模式"
            }

            val deeee = when (newMode) {
                1 -> "{1, 1, 1, 1}" // 舒适
                2 -> "{1, 2, 2, 2}" // 运动
                3 -> "{1, 2, 2, 2}" // 经济
                4 -> "{1, 1, 1, 1}"// 专属(与舒适相同，实际应弹窗选择)
//                5 -> intArrayOf(1, 1, 1, 1) // 自定义(实际应使用保存的自定义值)
                else -> "默认{1, 1, 1, 1}"
            }

            deviceEventsFlow.emit(DeviceEvent.SetFunction("", modeDesc))
            Timber.tag(TAG).w("设置驾驶模式为: $modeDesc ($deeee)")
            return ""
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "切换驾驶模式失败")
            return "操作失败"
        }
    }
    
    /**
     * 切换能量管理模式
     * 
     * ID: 0x4000015 (ID_DRV_ENERGY_MODE)
     * 值类型: int
     * 值说明:
     *   0=关闭
     *   1=开启
     * 
     * @return 当前模式描述
     */
    suspend fun adjustEnergyManagement() {
        Timber.tag(TAG).w("切换能量管理模式")
        try {
            // 获取当前能量管理模式
            val currentMode = mCarProperty.getIntProp(ID_DRV_ENERGY_MODE)
            Timber.tag(TAG).w("当前能量管理模式: $currentMode")
            
            // 切换状态 (0→1, 1→0)
            val newMode = when (currentMode) {
                0 -> 1  // 市区
                1 -> 2  // 高速
                2 -> 0  // 山地
                else -> 1 // 市区
            }
            
            // 设置新的能量管理模式
            mCarProperty.setIntProp(ID_DRV_ENERGY_MODE, newMode)


            val newModeString = when (newMode) {
                0 -> "市区模式"  // 舒适→运动
                1 -> "高速模式"  // 运动→经济
                2 -> "山地模式"
                else -> ""
            }
            deviceEventsFlow.emit(DeviceEvent.SetFunction("", newModeString))
            Timber.tag(TAG).w("设置能量管理模式为: $newMode")

        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "切换能量管理模式失败")

        }
    }

    /**
     * 切换除雾除霜状态
     * 前后除霜除雾
     * ID_REQ_FRONT_DEFROST = 0x2000036
     * 前除霜：0x1
     * 后除霜：0x2
     * 关闭：OFF = 0x01,
     * 开启：ON = 0x02,
     * 循环模式为前开->后开->前关->后关->前开
     */
    private suspend fun toggleDefrost() :String {
        Timber.tag(TAG).w("切换除雾除霜状态")
        try {
            // 获取当前除雾除霜状态
            val currentMode1 = mCarProperty.getIntProp(ID_REQ_FRONT_DEFROST)
            val currentMode2 = mCarProperty.getIntProp(ID_REAR_DEFROST)
            Timber.tag(TAG).w("切换除雾除霜状态: 前：$currentMode1，后：$currentMode2")

            // 循环除雾除霜模式: 前开->后开->前关->后关->前开
            val newMode1 = when (currentMode1) {
                0 -> 0x01  //前关后关->前开后关
                1 -> 0x00  //前开后关->前开后开
                else -> 0x01
            }

            val newMode2 = when (currentMode2) {
                0 -> 0x01  //前关后关->前开后关
                1 -> 0x00  //前开后关->前开后开
                else -> 0x01
            }


            // 设置新的除雾除霜模式
            mCarProperty.setIntProp(ID_REQ_FRONT_DEFROST, newMode1)
            mCarProperty.setIntProp(ID_REAR_DEFROST, newMode2)

            // 输出设置后的除雾除霜模式
            val mode1Desc = when (newMode1) {
                0x00 -> "前关"
                0x01 -> "前开"
                else -> "未知"
            }
            val mode2Desc = when (newMode2) {
                0x00 -> "后关"
                0x01 -> "后开"
                else -> "未知"
            }
            //deviceEventsFlow.emit(DeviceEvent.SetFunction("", "除雾除霜 $mode1Desc ，$mode2Desc"))
            Timber.tag(TAG).w("设置除雾除霜模式: $mode1Desc ($newMode1)，$mode2Desc ($newMode2)")
            return mode1Desc + mode2Desc
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "调节除雾除霜模式失败")
            return "操作失败"
        }
    }

    /**
     * 切换除雾除霜状态
     * 前后除霜除雾
     * ID_REQ_FRONT_DEFROST = 0x2000036
     * 前除霜：0x1
     * 后除霜：0x2
     * 关闭：OFF = 0x01,
     * 开启：ON = 0x02,
     * 循环模式为前开->后开->前关->后关->前开
     */
    private suspend fun toggleDefrost1() :String {
        Timber.tag(TAG).w("切换前除雾除霜状态")
        try {
            // 获取当前除雾除霜状态
            val currentMode1 = mCarProperty.getIntProp(ID_REQ_FRONT_DEFROST)

            Timber.tag(TAG).w("切换前除雾除霜状态: $currentMode1")

            // 循环除雾除霜模式: 前开->后开->前关->后关->前开
            val newMode1 = when (currentMode1) {
                0 -> 0x01  //前关后关->前开后关
                1 -> 0x00  //前开后关->前开后开
                else -> 0x01
            }


            // 设置新的除雾除霜模式
            mCarProperty.setIntProp(ID_REQ_FRONT_DEFROST, newMode1)

            // 输出设置后的除雾除霜模式
            val mode1Desc = when (newMode1) {
                0x00 -> "关闭"
                0x01 -> "开启"
                else -> "未知"
            }

            //deviceEventsFlow.emit(DeviceEvent.SetFunction("", "除雾除霜 $mode1Desc ，$mode2Desc"))
            Timber.tag(TAG).w("设置前除雾除霜: $mode1Desc ($newMode1))")
            return mode1Desc
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "调节前除雾除霜模式失败")
            return "操作失败"
        }
    }


    /**
     * 切换除雾除霜状态
     * 前后除霜除雾
     * ID_REQ_FRONT_DEFROST = 0x2000036
     * 前除霜：0x1
     * 后除霜：0x2
     * 关闭：OFF = 0x01,
     * 开启：ON = 0x02,
     * 循环模式为前开->后开->前关->后关->前开
     */
    private suspend fun toggleDefrost2() :String {
        Timber.tag(TAG).w("切换后除雾除霜状态")
        try {
            // 获取当前除雾除霜状态

            val currentMode2 = mCarProperty.getIntProp(ID_REAR_DEFROST)
            Timber.tag(TAG).w("切换后除雾除霜状态: $currentMode2")

            val newMode2 = when (currentMode2) {
                0 -> 0x01  //前关后关->前开后关
                1 -> 0x00  //前开后关->前开后开
                else -> 0x01
            }


            // 设置新的除雾除霜模式

            mCarProperty.setIntProp(ID_REAR_DEFROST, newMode2)


            val mode2Desc = when (newMode2) {
                0x00 -> "关闭"
                0x01 -> "开启"
                else -> "未知"
            }
            //deviceEventsFlow.emit(DeviceEvent.SetFunction("", "除雾除霜 $mode1Desc ，$mode2Desc"))
            Timber.tag(TAG).w("设置后除雾除霜: $mode2Desc ($newMode2)")
            return mode2Desc
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "调节后除雾除霜模式失败")
            return "操作失败"
        }
    }


    /**
     * 切换中央控制状态
     */
    private fun toggleCentralControl() {
        Timber.tag(TAG).w("切换中央控制状态")
        // TODO: 实现中央控制状态切换逻辑
    }


    // 空调温度范围（摄氏度）
    private val minTemperature = 17.5f
    private val maxTemperature = 32.5f
    private val temperatureStep = 0.5f
    
    // 空调风量范围
    private val minFanSpeed = 1
    private val maxFanSpeed = 10

    /**
     * 提高空调温度
     * 同时设置主驾和副驾温度
     * 
     * ID: 0x2000077 (ID_TEMPERATURE_FRONTLEFT)
     * ID: 0x2000078 (ID_TEMPERATURE_FRONTRIGHT)
     * 值类型: float
     * 值说明: 
     *   17.5-32.5 步进0.5
     * 
     * @return 调整后的温度
     */
    fun increaseACTemperature(): Float {
        Timber.tag(TAG).w("提高空调温度")
        try {
            // 获取当前主驾温度
            val currentTemp = mCarProperty.getFloatProp(ID_TEMPERATURE_FRONTLEFT)
            Timber.tag(TAG).w("当前空调温度: $currentTemp°C")

            // 计算新温度，不超过最大值
            var newTemp = minOf(currentTemp + temperatureStep, maxTemperature)

            // 设置新温度（主驾和副驾）
            mCarProperty.setFloatProp(ID_TEMPERATURE_FRONTLEFT, newTemp)

            Timber.tag(TAG).w("空调温度已设置为: $newTemp°C")
            return newTemp
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "提高空调温度失败")
            return 0f
        }
    }

    fun increaseACTemperature2(): Float {
        Timber.tag(TAG).w("提高空调温度")
        try {
            // 获取当前主驾温度
            val currentTemp = mCarProperty.getFloatProp(ID_TEMPERATURE_FRONTRIGHT)
            Timber.tag(TAG).w("当前空调温度: $currentTemp°C")

            // 计算新温度，不超过最大值
            var newTemp = minOf(currentTemp + temperatureStep, maxTemperature)

            // 设置新温度（主驾和副驾）
            mCarProperty.setFloatProp(ID_TEMPERATURE_FRONTRIGHT, newTemp)

            Timber.tag(TAG).w("空调温度已设置为: $newTemp°C")
            return newTemp
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "提高空调温度失败")
            return 0f
        }
    }
    
    /**
     * 降低空调温度
     * 同时设置主驾和副驾温度
     * 
     * ID: 0x2000077 (ID_TEMPERATURE_FRONTLEFT)
     * ID: 0x2000078 (ID_TEMPERATURE_FRONTRIGHT)
     * 值类型: float
     * 值说明: 
     *   17.5-32.5 步进0.5
     * 
     * @return 调整后的温度
     */
    fun decreaseACTemperature(): Float {
        Timber.tag(TAG).w("降低空调温度")
        try {
            // 获取当前主驾温度
            val currentTemp = mCarProperty.getFloatProp(ID_TEMPERATURE_FRONTLEFT)
            Timber.tag(TAG).w("当前空调温度: $currentTemp°C")
            
            // 计算新温度，不低于最小值
            var newTemp = maxOf(currentTemp - temperatureStep, minTemperature)
            
            // 设置新温度（主驾和副驾）
            mCarProperty.setFloatProp(ID_TEMPERATURE_FRONTLEFT, newTemp)
            
            Timber.tag(TAG).w("空调温度已设置为: $newTemp°C")
            return newTemp
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "降低空调温度失败")
            return 0f
        }
    }

    fun decreaseACTemperature2(): Float {
        Timber.tag(TAG).w("降低空调温度")
        try {
            // 获取当前主驾温度
            val currentTemp = mCarProperty.getFloatProp(ID_TEMPERATURE_FRONTRIGHT)
            Timber.tag(TAG).w("当前空调温度: $currentTemp°C")

            // 计算新温度，不低于最小值
            var newTemp = maxOf(currentTemp - temperatureStep, minTemperature)

            // 设置新温度（主驾和副驾）
            mCarProperty.setFloatProp(ID_TEMPERATURE_FRONTRIGHT, newTemp)

            Timber.tag(TAG).w("空调温度已设置为: $newTemp°C")
            return newTemp
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "降低空调温度失败")
            return 0f
        }
    }

    /**
     * 增加风扇速度
     * 
     * ID: 0x200007e (ID_BLW_LEVEL_FRONT)
     * 值类型: int
     * 值说明: 
     *   1-8 对应1-8档
     * 
     * @return 调整后的风扇速度
     */
    suspend fun increaseFanSpeed(): Int {
        Timber.tag(TAG).w("提高空调风量")
        try {
            // 获取当前风量
            val currentSpeed = mCarProperty.getIntProp(ID_BLW_LEVEL_FRONT)
            Timber.tag(TAG).w("当前空调风量: $currentSpeed")



            val newSpeed = when (currentSpeed) {
                0x1 -> 0x2
                0x2 -> 0x3
                0x3 -> 0x4
                0x4 -> 0x5
                0x5 -> 0x6
                0x6 -> 0x7
                0x7 -> 0x8
                0x8 -> 0xB
                0xB -> 0xC
                0xC -> 0xC
                else -> 0x01
            }

            // 输出设置后的除雾除霜模式
            val mode1Desc = when (newSpeed) {
                0x1 -> "1"
                0x2 -> "2"
                0x3 -> "3"
                0x4 -> "4"
                0x5 -> "5"
                0x6 -> "6"
                0x7 -> "7"
                0x8 -> "8"
                0xB -> "9"
                0xC -> "10"
                else -> "未知"
            }

            // 计算新风量，不超过最大值
            //val newSpeed = minOf(currentSpeed + 1, maxFanSpeed)
            
            // 设置新风量
            mCarProperty.setIntProp(ID_BLW_LEVEL_FRONT, 0x9)

            //deviceEventsFlow.emit(DeviceEvent.SetFunction("", "空调风量 +"))

            Timber.tag(TAG).w("空调风量已设置为: $newSpeed")
            return newSpeed
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "提高空调风量失败")
            return 0
        }
    }
    
    /**
     * 降低风扇速度
     * 
     * ID: 0x200007e (ID_BLW_LEVEL_FRONT)
     * 值类型: int
     * 值说明: 
     *   1-8 对应1-8档
     * 
     * @return 调整后的风扇速度
     */
    suspend fun decreaseFanSpeed(): Int {
        Timber.tag(TAG).w("降低空调风量")
        try {
            // 获取当前风量
            val currentSpeed = mCarProperty.getIntProp(ID_BLW_LEVEL_FRONT)
            Timber.tag(TAG).w("当前空调风量: $currentSpeed")


            val newSpeed = when (currentSpeed) {
                0x1 -> 0x1
                0x2 -> 0x1
                0x3 -> 0x2
                0x4 -> 0x3
                0x5 -> 0x4
                0x6 -> 0x5
                0x7 -> 0x6
                0x8 -> 0x7
                0xB -> 0x8
                0xC -> 0xB
                else -> 0x00
            }

            // 输出设置后的除雾除霜模式
            val mode1Desc = when (newSpeed) {
                0x0 -> "已关闭"
                0x1 -> "1"
                0x2 -> "2"
                0x3 -> "3"
                0x4 -> "4"
                0x5 -> "5"
                0x6 -> "6"
                0x7 -> "7"
                0x8 -> "8"
                0xA -> "9"
                0xB -> "10"
                else -> "未知"
            }
            // 计算新风量，不低于最小值
//            val newSpeed = maxOf(currentSpeed - 1, minFanSpeed)
            
            // 设置新风量
            mCarProperty.setIntProp(ID_BLW_LEVEL_FRONT, 0xA)

            //deviceEventsFlow.emit(DeviceEvent.SetFunction("", "空调风量 —"))
            
            Timber.tag(TAG).w("空调风量已设置为: $newSpeed")
            return newSpeed
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "降低空调风量失败")
            return 0
        }
    }

    /**
     * 调节空调吹风方向
     * 
     * ID: 0x2000084 (ID_BLW_DIRECT_FRONT)
     * 值类型: int
     * 值说明:
     *   1=吹脸
     *   2=吹脚
     *   3=吹脸吹脚
     *   4=除霜
     *   5=吹脸除霜
     *   6=吹脚除霜
     *   7=吹脸吹脚除霜
     *   9=自动
     *
     *   7种模式都有的车型：385MCA，D587,673-5,C385-2,C673-6。其余车型都是5种
     */
    suspend fun adjustAcWindDirection(): String {
        Timber.tag(TAG).w("调节空调吹风方向")
        try {
            var isFive:Boolean =true
            var model = MegaSystemProperties.getInt(DriveModelManager.PROP_ECU_CONFIG_C385_VEHICLE_TYPE, 0);
            var model2 = MegaSystemProperties.getInt(DriveModelManager.PROP_ECU_CONFIG_SUB_VEHICLEMODEL, 0);

            if(model2==0)
            {
                if(model==3||model==24||model==21||model==22)
                {
                    isFive=false
                }
            }else{
                if (model2==2)
                {
                    isFive=false
                }
            }
            var newDirection: Int=1
            // 获取当前吹风方向
            val currentDirection = mCarProperty.getIntProp(ID_BLW_DIRECT_FRONT)
            Timber.tag(TAG).w("当前吹风方向: $currentDirection")

            if(isFive){
                newDirection = when (currentDirection) {
                    1 -> 3  // 吹脸→吹脸吹脚
                    2 -> 6  // 吹脚→吹脚除霜
                    3 -> 2  // 吹脸吹脚→吹脚
                    4 -> 1  // 除霜->吹脸
                    6 -> 4  // 吹脚除霜->除霜
                    else -> 1 // 其他→吹脸
                }
            }else {
                newDirection = when (currentDirection) {
                    1 -> 2  // 吹脸→吹脚
                    2 -> 3  // 吹脚→吹脸吹脚
                    3 -> 4  // 吹脸吹脚→除霜
                    4 -> 5  // 除霜->吹脸除霜
                    5 -> 6  // 吹脸除霜->吹脚除霜
                    6 -> 7  // 吹脚除霜->吹脸吹脚除霜
                    else -> 1 // 其他→吹脸
                }
            }
            // 设置新的吹风方向
            mCarProperty.setIntProp(ID_BLW_DIRECT_FRONT, newDirection)
            
            // 获取吹风方向描述
            val directionDesc = when (newDirection) {
                1 -> "吹脸"
                2 -> "吹脚"
                3 -> "吹脸吹脚"
                4 -> "除霜"
                5 -> "吹脸除霜"
                6 -> "吹脚除霜"
                7 -> "吹脸吹脚除霜"
                9 -> "自动"
                else -> "未知"
            }
            //deviceEventsFlow.emit(DeviceEvent.SetFunction("", directionDesc))
            Timber.tag(TAG).w("设置吹风方向为: $directionDesc ($newDirection)")
            return directionDesc
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "调节空调吹风方向失败")
            return "操作失败"
        }
    }

    /**
     * 调节按摩强度
     * 主驾和副驾同时设置
     * 
     * ID: 0x64000180 (ID_DSM_PARK_MASSAGE_STR) - 主驾
     * ID: 0x64000184 (ID_PSM_PARK_MASSAGE_STR) - 副驾
     * 值类型: int
     * 值说明:
     *   0=关闭
     *   1=低档
     *   2=中档
     *   3=高档
     */
    private fun adjustMassageIntensity() {
        Timber.tag(TAG).w("调节按摩强度")
        try {
            // 获取当前主驾按摩强度
            val currentLevel = mCarProperty.getIntProp(ID_DSM_PARK_MASSAGE_STR)
            Timber.tag(TAG).w("当前按摩强度: $currentLevel")
            
            // 循环切换强度 (0→1→2→3→0)
            val newLevel = (currentLevel + 1) % 4
            
            // 设置新强度（主驾和副驾）
            mCarProperty.setIntProp(ID_DSM_PARK_MASSAGE_STR, newLevel)
            mCarProperty.setIntProp(ID_PSM_PARK_MASSAGE_STR, newLevel)
            
            val levelDesc = when (newLevel) {
                0 -> "关闭"
                1 -> "低档"
                2 -> "中档"
                3 -> "高档"
                else -> "未知"
            }
            Timber.tag(TAG).w("设置按摩强度为: $levelDesc ($newLevel)")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "调节按摩强度失败")
        }
    }
    
    /**
     * 调整按摩模式
     * 主驾和副驾同时设置
     * 
     * ID: 0x6400017f (ID_DSM_PARK_MASSAGE_MOD) - 主驾
     * ID: 0x64000183 (ID_PSM_PARK_MASSAGE_MOD) - 副驾
     * 值类型: int
     * 值说明:
     *   0=模式1波浪
     *   1=模式2猫步
     *   2=模式3蛇形
     *   3=模式4肩部
     *   4=模式5腰部
     *   5=模式6脉冲
     *   6=模式7舒适
     *   7=模式8推拿
     */
    private fun adjustMassageMode() {
        Timber.tag(TAG).w("调整按摩模式")
        try {
            // 获取当前主驾按摩模式
            val currentMode = mCarProperty.getIntProp(ID_DSM_PARK_MASSAGE_MOD)
            Timber.tag(TAG).w("当前按摩模式: $currentMode")
            
            // 循环切换模式 (0→1→...→7→0)
            val newMode = (currentMode + 1) % 8
            
            // 设置新模式（主驾和副驾）
            mCarProperty.setIntProp(ID_DSM_PARK_MASSAGE_MOD, newMode)
            mCarProperty.setIntProp(ID_PSM_PARK_MASSAGE_MOD, newMode)
            
            val modeDesc = when (newMode) {
                0 -> "模式1波浪"
                1 -> "模式2猫步"
                2 -> "模式3蛇形"
                3 -> "模式4肩部"
                4 -> "模式5腰部"
                5 -> "模式6脉冲"
                6 -> "模式7舒适"
                7 -> "模式8推拿"
                else -> "未知"
            }
            Timber.tag(TAG).w("设置按摩模式为: $modeDesc ($newMode)")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "调整按摩模式失败")
        }
    }

    /**
     * 调节尾翼位置
     * 
     * ID: 0x64000221 (ID_PTS_ELE_TAIL_FUN_SET)
     * 值类型: int
     * 值说明:
     *   1=关闭
     *   2=开启
     *   3=随车速响应
     *   4=随运动模式开启
     * 
     * @return 当前位置描述
     */
    suspend fun adjustTailWingPosition(): String {
        Timber.tag(TAG).w("调节尾翼位置")
        try {
            // 获取当前尾翼状态
            val currentPosition = mCarProperty.getIntProp(ID_PTS_ELE_TAIL_FUN_SET)
            Timber.tag(TAG).w("当前尾翼位置: $currentPosition")
            
            // 循环切换位置: 1→2→3→4→1
            val newPosition = when (currentPosition) {
                0 -> 2  // 关闭→开启
                1 -> 3  // 开启→随车速响应
                2 -> 4  // 随车速响应→随运动模式开启
                else -> 1 // 其他→关闭
            }
            
            // 设置新的尾翼位置
            mCarProperty.setIntProp(ID_PTS_ELE_TAIL_FUN_SET, newPosition)
            
            val positionDesc = when (newPosition) {
                1 -> "关闭"
                2 -> "开启"
                3 -> "随车速响应"
                4 -> "随运动模式开启"
                else -> "未知"
            }
            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "尾翼 $positionDesc"))
            Timber.tag(TAG).w("设置尾翼位置为: $positionDesc ($newPosition)")
            return positionDesc
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "调节尾翼位置失败")
            return "操作失败"
        }
    }
    
    /**
     * 调节副驾屏展开度数
     * 
     * ID: 0x6400011e (ID_CDC_TURN_VOICE_CTRL)
     * 值类型: int
     * 值说明:
     *   0x00-0x87: 0-135度
     *   0x88: 无请求
     * 
     * @return 当前角度描述
     */
    fun adjustCopilotScreen(): String {
        Timber.tag(TAG).w("调节副驾屏展开度数")
        try {
            // 获取当前副驾屏角度
            val currentAngle = mCarProperty.getIntProp(ID_CDC_TURN_VOICE_CTRL)
            Timber.tag(TAG).w("当前副驾屏角度值: $currentAngle")
            
            // 计算角度(十六进制值对应的角度)
            val currentDegree = if (currentAngle in 0x00..0x87) {
                (currentAngle.toFloat() / 0x87.toFloat() * 135f).toInt()
            } else {
                0
            }
            
            // 循环切换角度: 0→45→90→135→0
            val newDegree = when {
                currentDegree < 30 -> 45
                currentDegree < 70 -> 90
                currentDegree < 110 -> 135
                else -> 0
            }
            
            // 计算对应的十六进制值
            val newAngle = (newDegree.toFloat() / 135f * 0x87.toFloat()).toInt()
            
            // 设置新的副驾屏角度
            mCarProperty.setIntProp(ID_CDC_TURN_VOICE_CTRL, newAngle)
            
            Timber.tag(TAG).w("设置副驾屏角度为: ${newDegree}度 (值=$newAngle)")
            return "${newDegree}度"
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "调节副驾屏展开度数失败")
            return "操作失败"
        }
    }
}